home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / rpcecho / rpcecho.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-28  |  6.3 KB  |  252 lines
  1. /*
  2.  * rpcecho - do a series of rpc Echoes to a server for testing.
  3.  */
  4. #include "sprite.h"
  5. #include "fs.h"
  6. #include "fsCmd.h"
  7. #include "stdio.h"
  8. #include "rpc.h"
  9. #include "netEther.h"
  10. #include "kernel/rpcPacket.h"
  11. #include "proc.h"
  12. #include "option.h"
  13. #include "host.h"
  14. #include "sysStats.h"
  15.  
  16. /*
  17.  * Default values for parameters
  18.  */
  19. char *server = NULL;
  20. int numEchoes = 100;
  21. #define DATASIZE    32
  22. int size = DATASIZE;
  23. int maxSize = 16 * 1024;
  24. int numReps = 10;
  25.  
  26. #define BYTES_PER_FRAG    (NET_ETHER_MAX_BYTES - sizeof(RpcHdr))
  27. /*
  28.  * Buffer areas for data sent and received
  29.  */
  30. #define BUFSIZE (16 * 1024)
  31. char inDataBuffer[BUFSIZE];
  32. char outDataBuffer[BUFSIZE];
  33.  
  34. /*
  35.  * Server flags set by command line arguments
  36.  */
  37. Boolean doEchoes = TRUE;
  38. Boolean doSends = FALSE;
  39. Boolean fastCS = FALSE;
  40. Boolean trace = FALSE;
  41. Boolean allSizes = FALSE;
  42. Boolean reverse = FALSE;
  43.  
  44.  
  45. Option optionArray[] = {
  46.     OPT_INT, "n", (Address)&numEchoes, "Number of RPCs to do",
  47.     OPT_INT, "d", (Address)&size, "Datasize to transmit",
  48.     OPT_TRUE, "D", (Address)&allSizes, "Do tests at all sizes",
  49.     OPT_TRUE, "R", (Address)&reverse, "Do all sizes, high-to-low",
  50.     OPT_TRUE, "e", (Address)&doEchoes, "Echo off RPC server (default)",
  51.     OPT_INT, "r", (Address)&numReps, "Number of reps for each size",
  52.     OPT_TRUE, "s", (Address)&doSends, "Send instead of Echo",
  53.     OPT_TRUE, "t", (Address)&trace, "Trace records taken (runs slower)",
  54.     OPT_TRUE, "c", (Address)&fastCS, "High priority",
  55.     OPT_STRING, "h", (Address)&server, "name of target host",
  56. };
  57. int numOptions = sizeof(optionArray) / sizeof(Option);
  58.  
  59. main(argc, argv)
  60.     int argc;
  61.     char *argv[];
  62. {
  63.     int error;
  64.     int openFileId;
  65.     char c;
  66.     char *fileName;
  67.     Time deltaTime;
  68.     Boolean oldTrace;
  69.     int command;
  70.     Host_Entry *entryPtr;
  71.     int serverID;
  72.     int myID;
  73.     Rpc_CltStat cltStat;
  74.  
  75.     argc = Opt_Parse(argc, argv, optionArray, numOptions);
  76.  
  77.     if (server == NULL) {
  78.     fprintf(stderr, "Need a target host (-h hostname)\n");
  79.     Opt_PrintUsage(argv[0], optionArray, numOptions);
  80.     exit(1);
  81.     }
  82.     if (size < 0) {
  83.     size = 0;
  84.     } else if (size > 16384) {
  85.     size = 16384;
  86.     }
  87.  
  88.     entryPtr = Host_ByName(server);
  89.     if (entryPtr == (Host_Entry *) NULL) {
  90.     fprintf(stderr, "Unable to get host number for host '%s'\n",
  91.                server);
  92.     exit(1);
  93.     }
  94.     serverID = entryPtr->id;
  95.  
  96.     if (doSends) {
  97.     printf("Rpc Send Test: N = %d, Host = %s (%d),",
  98.             numEchoes, server, serverID);
  99.     } else {
  100.     printf("Rpc Send Test: N = %d, Host = %s (%d),",
  101.             numEchoes, server, serverID);
  102.     }
  103.     if (reverse) allSizes = TRUE;
  104.     if (allSizes) {
  105.     printf(" all sizes\n");
  106.     } else {
  107.         printf(" size = %d\n", size);
  108.     }
  109.  
  110.     if (fastCS) {
  111.     error = Proc_SetPriority(PROC_MY_PID, PROC_NO_INTR_PRIORITY, FALSE);
  112.     if (error != SUCCESS) {
  113.         perror( "");
  114.     }
  115.     }
  116.         
  117.  
  118.     if (trace) {
  119.     oldTrace = TRUE;
  120.     (void) Fs_Command(FS_SET_RPC_TRACING, sizeof(int), &oldTrace);
  121.     }
  122.     command = doSends ? TEST_RPC_SEND : TEST_RPC_ECHO ;
  123.  
  124.     if (!allSizes) {
  125.     error = DoTest(command, serverID, numEchoes, size,
  126.             inDataBuffer, outDataBuffer, &deltaTime, &cltStat);
  127.     printf("N = %d Size = ", numEchoes);
  128.     PrintTime(size, &deltaTime, &cltStat);
  129.     if (error != 0) {
  130.         printf("status %x\n", error);
  131.     }
  132.     } else {
  133.     int extra;
  134.     error = DoTest(command, serverID, 10, 32,
  135.             inDataBuffer, outDataBuffer, &deltaTime, &cltStat);
  136.     if (error != SUCCESS) {
  137.         fprintf(stderr, "RPC test failed: %x\n", error);
  138.         exit(error);
  139.     }
  140.     if (size != DATASIZE) {
  141.         maxSize = size;
  142.     }
  143.     if (! reverse) {
  144.         for (size = 0; size < maxSize ; size += BYTES_PER_FRAG) {
  145.         DoIt(command, serverID, numEchoes, size);
  146.         for (extra = 400 ; (extra < BYTES_PER_FRAG) &&
  147.             (size+extra < maxSize) ; extra += 400) {
  148.             DoIt(command, serverID, numEchoes, size+extra);
  149.         }
  150.         }
  151.     } else {
  152.         size = (maxSize / BYTES_PER_FRAG) * BYTES_PER_FRAG;
  153.         for ( ; size >= 0 ; size -= BYTES_PER_FRAG) {
  154.         DoIt(command, serverID, numEchoes, size);
  155.         for (extra = 250 ; (extra < BYTES_PER_FRAG) &&
  156.             (size-extra >= 0) ; extra += 400) {
  157.             DoIt(command, serverID, numEchoes, size-extra);
  158.         }
  159.         }
  160.     }
  161.     }
  162.     if (trace) {
  163.     (void) Fs_Command(FS_SET_RPC_TRACING, sizeof(int), &oldTrace);
  164.     }
  165.  
  166.     exit(error);
  167. }
  168.  
  169. DoIt(command, serverID, numEchoes, size)
  170.     int command, serverID, numEchoes, size;
  171. {
  172.     Time deltaTime;
  173.     register int i;
  174.     ReturnStatus error;
  175.     Rpc_CltStat cltStat;
  176.  
  177.     fprintf(stderr, "%5d bytes\n", size);
  178.     for (i=0 ; i<numReps ; i++) {
  179.     error = DoTest(command, serverID, numEchoes, size ,
  180.         inDataBuffer, outDataBuffer, &deltaTime, &cltStat);
  181.     PrintTime(size, &deltaTime, &cltStat);
  182.     if (error != SUCCESS) {
  183.         perror( "RPC test failed:");
  184.         exit(error);
  185.     }
  186.     }
  187. }
  188.  
  189. PrintTime(size, timePtr, cltStatPtr)
  190.     int size;
  191.     Time *timePtr;
  192.     Rpc_CltStat *cltStatPtr;
  193. {
  194.     printf("%d\t%d.%06d ", size, timePtr->seconds, timePtr->microseconds);
  195.     if (cltStatPtr->timeouts > 0) {
  196.     printf("timeouts %d ", cltStatPtr->timeouts);
  197.     }
  198.     if (cltStatPtr->resends > 0) {
  199.     printf("resends %d ", cltStatPtr->resends);
  200.     }
  201.     if (cltStatPtr->acks > 0) {
  202.     printf("acks %d ", cltStatPtr->acks);
  203.     }
  204.     printf("\n");
  205.     fflush(stdout);
  206. }
  207.  
  208. ReturnStatus
  209. DoTest(command, serverID, numEchoes, size, inDataBuffer, outDataBuffer,
  210.     timePtr, cltStatPtr)
  211.     int command;
  212.     int serverID;
  213.     int numEchoes;
  214.     int size;
  215.     Address inDataBuffer;
  216.     Address outDataBuffer;
  217.     Time *timePtr;
  218.     Rpc_CltStat *cltStatPtr;
  219. {
  220.     Rpc_EchoArgs echoArgs;
  221.     ReturnStatus error;
  222.     Rpc_CltStat startCltStat;
  223.  
  224.     if (Sys_Stats(SYS_RPC_CLT_STATS, TRUE, &startCltStat) != SUCCESS) {
  225.     bzero((char *)&startCltStat, sizeof(Rpc_CltStat));
  226.     }
  227.  
  228.     echoArgs.serverID = serverID;
  229.     echoArgs.n = numEchoes;
  230.     echoArgs.size = size;
  231.     echoArgs.inDataPtr = inDataBuffer;
  232.     echoArgs.outDataPtr = outDataBuffer;
  233.     echoArgs.deltaTimePtr = timePtr;
  234.     error = Test_Rpc(command, &echoArgs);
  235.  
  236.     if (Sys_Stats(SYS_RPC_CLT_STATS, TRUE, cltStatPtr) != SUCCESS) {
  237.     bzero((char *)cltStatPtr, sizeof(Rpc_CltStat));
  238.     } else {
  239.     register int *beforePtr, *afterPtr;
  240.     register int wordCount = 0;
  241.  
  242.     for (wordCount = 0,
  243.          beforePtr = (int *)&startCltStat, afterPtr = (int *)cltStatPtr;
  244.          wordCount < sizeof(Rpc_CltStat) / sizeof(int) ;
  245.          wordCount++, beforePtr++, afterPtr++) {
  246.         *afterPtr = *afterPtr - *beforePtr;
  247.     }
  248.     }
  249.  
  250.     return(error);
  251. }
  252.